package com.dkd.manage.service.impl;

import java.math.BigDecimal;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.stream.Collectors;
import com.dkd.common.utils.DateUtils;
import com.dkd.common.exception.ServiceException;
import com.dkd.manage.mapper.SkuClassMapper;
import com.dkd.manage.mapper.SkuMapper;
import com.dkd.manage.domain.Sku;
import com.dkd.manage.domain.SkuClass;
import com.dkd.manage.service.ISkuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFCell;
import java.io.InputStream;
import java.io.IOException;

/**
 * 商品Service业务层处理
 *
 * @author ruoyi
 * @date 2025-11-10
 */
@Service
public class SkuServiceImpl implements ISkuService
{
    @Autowired
    private SkuMapper skuMapper;

    @Autowired
    private SkuClassMapper skuClassMapper;

    /**
     * 查询商品
     *
     * @param id 商品主键
     * @return 商品
     */
    @Override
    public Sku selectSkuById(Long id)
    {
        return skuMapper.selectSkuById(id);
    }

    /**
     * 查询商品列表
     *
     * @param sku 商品
     * @return 商品
     */
    @Override
    public List<Sku> selectSkuList(Sku sku)
    {
        return skuMapper.selectSkuList(sku);
    }

    /**
     * 查询启用的商品列表
     *
     * @param sku 查询条件
     * @return 启用商品列表
     */
    @Override
    public List<Sku> selectActiveSkuList(Sku sku)
    {
        return skuMapper.selectActiveSkuList(sku);
    }

    /**
     * 新增商品
     *
     * @param sku 商品
     * @return 结果
     */
    @Override
    @Transactional
    public int insertSku(Sku sku)
    {
        // 校验商品编码唯一性
        if (!checkSkuCodeUnique(sku))
        {
            throw new ServiceException("商品编码已存在");
        }

        // 查询分类名称
        if (sku.getSkuClassId() != null)
        {
            SkuClass skuClass = skuClassMapper.selectSkuClassById(sku.getSkuClassId());
            if (skuClass != null)
            {
                sku.setSkuClassName(skuClass.getClassName());
            }
        }

        sku.setCreateTime(DateUtils.getNowDate());
        return skuMapper.insertSku(sku);
    }

    /**
     * 修改商品
     *
     * @param sku 商品
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSku(Sku sku)
    {
        // 校验商品编码唯一性
        if (!checkSkuCodeUnique(sku))
        {
            throw new ServiceException("商品编码已存在");
        }

        // 查询分类名称
        if (sku.getSkuClassId() != null)
        {
            SkuClass skuClass = skuClassMapper.selectSkuClassById(sku.getSkuClassId());
            if (skuClass != null)
            {
                sku.setSkuClassName(skuClass.getClassName());
            }
        }

        sku.setUpdateTime(DateUtils.getNowDate());
        return skuMapper.updateSku(sku);
    }

    /**
     * 批量删除商品
     *
     * @param ids 需要删除的商品主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSkuByIds(Long[] ids)
    {
        // 逻辑外键校验：检查商品是否被货道引用
        int referencedCount = skuMapper.checkSkusReferencedByChannel(ids);
        if (referencedCount > 0)
        {
            throw new ServiceException("有 " + referencedCount + " 个商品正在被货道使用，不能删除");
        }

        return skuMapper.deleteSkuByIds(ids);
    }

    /**
     * 删除商品信息
     *
     * @param id 商品主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSkuById(Long id)
    {
        // 逻辑外键校验：检查商品是否被货道引用
        int referencedCount = skuMapper.checkSkuReferencedByChannel(id);
        if (referencedCount > 0)
        {
            throw new ServiceException("该商品正在被 " + referencedCount + " 个货道使用，不能删除");
        }

        return skuMapper.deleteSkuById(id);
    }

    /**
     * 导入商品数据
     *
     * @param file Excel文件
     * @param updateSupport 是否更新支持
     * @param operName 操作用户
     * @return 结果
     */
    @Override
    @Transactional
    public String importSku(MultipartFile file, boolean updateSupport, String operName)
    {
        try
        {
            // 获取所有分类信息
            List<SkuClass> skuClasses = skuClassMapper.selectSkuClassList(new SkuClass());
            Map<String, Long> classNameToIdMap = skuClasses.stream()
                    .collect(Collectors.toMap(SkuClass::getClassName, SkuClass::getId));

            InputStream inputStream = file.getInputStream();
            Workbook workbook = new XSSFWorkbook(inputStream);
            Sheet sheet = workbook.getSheetAt(0);

            int successNum = 0;
            int failureNum = 0;
            StringBuilder successMsg = new StringBuilder();
            StringBuilder failureMsg = new StringBuilder();

            // 从第二行开始读取（第一行是表头）
            for (int i = 1; i <= sheet.getLastRowNum(); i++)
            {
                Row row = sheet.getRow(i);
                if (row == null) continue;

                try
                {
                    Sku sku = new Sku();

                    // 读取商品编码（第0列）
                    Cell skuCodeCell = row.getCell(0);
                    if (skuCodeCell == null || getStringValue(skuCodeCell).trim().isEmpty())
                    {
                        failureNum++;
                        failureMsg.append("<br/>第").append(i + 1).append("行商品编码不能为空");
                        continue;
                    }
                    sku.setSkuCode(getStringValue(skuCodeCell).trim());

                    // 读取商品名称（第1列）
                    Cell skuNameCell = row.getCell(1);
                    if (skuNameCell == null || getStringValue(skuNameCell).trim().isEmpty())
                    {
                        failureNum++;
                        failureMsg.append("<br/>第").append(i + 1).append("行商品名称不能为空");
                        continue;
                    }
                    sku.setSkuName(getStringValue(skuNameCell).trim());

                    // 读取商品分类（第2列）
                    Cell classNameCell = row.getCell(2);
                    if (classNameCell != null && !getStringValue(classNameCell).trim().isEmpty())
                    {
                        String className = getStringValue(classNameCell).trim();
                        Long classId = classNameToIdMap.get(className);
                        if (classId != null)
                        {
                            sku.setSkuClassId(classId);
                            sku.setSkuClassName(className);
                        }
                        else
                        {
                            failureNum++;
                            failureMsg.append("<br/>第").append(i + 1).append("行商品分类不存在：").append(className);
                            continue;
                        }
                    }

                    // 读取品牌（第3列）
                    Cell brandCell = row.getCell(3);
                    if (brandCell != null)
                    {
                        sku.setBrand(getStringValue(brandCell).trim());
                    }

                    // 读取规格（第4列）
                    Cell specCell = row.getCell(4);
                    if (specCell != null)
                    {
                        sku.setSpec(getStringValue(specCell).trim());
                    }

                    // 读取单位（第5列）
                    Cell unitCell = row.getCell(5);
                    if (unitCell != null)
                    {
                        sku.setUnit(getStringValue(unitCell).trim());
                    }

                    // 读取价格（第6列）
                    Cell priceCell = row.getCell(6);
                    if (priceCell != null)
                    {
                        sku.setPrice(new BigDecimal(getNumericValue(priceCell)));
                    }
                    else
                    {
                        failureNum++;
                        failureMsg.append("<br/>第").append(i + 1).append("行价格不能为空");
                        continue;
                    }

                    // 读取图片URL（第7列）
                    Cell imageUrlCell = row.getCell(7);
                    if (imageUrlCell != null)
                    {
                        sku.setImageUrl(getStringValue(imageUrlCell).trim());
                    }

                    // 读取状态（第8列）
                    Cell statusCell = row.getCell(8);
                    if (statusCell != null)
                    {
                        String statusValue = getStringValue(statusCell).trim();
                        if ("上架".equals(statusValue) || "1".equals(statusValue))
                        {
                            sku.setStatus(1);
                        }
                        else
                        {
                            sku.setStatus(0);
                        }
                    }
                    else
                    {
                        sku.setStatus(1); // 默认上架
                    }

                    // 设置操作信息
                    sku.setCreateBy(operName);
                    sku.setCreateTime(DateUtils.getNowDate());

                    // 检查商品编码是否已存在
                    int count = skuMapper.checkSkuCodeUnique(sku.getSkuCode(), sku.getId());
                    if (count > 0)
                    {
                        if (updateSupport)
                        {
                            // 更新现有商品
                            skuMapper.updateSku(sku);
                            successNum++;
                        }
                        else
                        {
                            failureNum++;
                            failureMsg.append("<br/>商品编码 ").append(sku.getSkuCode()).append(" 已存在");
                        }
                    }
                    else
                    {
                        // 新增商品
                        skuMapper.insertSku(sku);
                        successNum++;
                    }
                }
                catch (Exception e)
                {
                    failureNum++;
                    failureMsg.append("<br/>第").append(i + 1).append("行导入失败：").append(e.getMessage());
                }
            }

            workbook.close();
            inputStream.close();

            if (failureNum > 0)
            {
                failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
                return failureMsg.toString();
            }
            else
            {
                successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条数据");
                return successMsg.toString();
            }
        }
        catch (Exception e)
        {
            return "导入商品数据失败：" + e.getMessage();
        }
    }

    /**
     * 获取单元格字符串值
     */
    private String getStringValue(Cell cell)
    {
        if (cell == null) return "";

        switch (cell.getCellType())
        {
            case STRING:
                return cell.getStringCellValue();
            case NUMERIC:
                return String.valueOf(cell.getNumericCellValue());
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                return cell.getCellFormula();
            default:
                return "";
        }
    }

    /**
     * 获取单元格数值
     */
    private String getNumericValue(Cell cell)
    {
        if (cell == null) return "0";

        switch (cell.getCellType())
        {
            case NUMERIC:
                return String.valueOf(cell.getNumericCellValue());
            case STRING:
                try
                {
                    return new BigDecimal(cell.getStringCellValue()).toString();
                }
                catch (Exception e)
                {
                    return "0";
                }
            default:
                return "0";
        }
    }

    /**
     * 导出商品数据
     *
     * @param sku 查询条件
     * @return Excel文件数据
     */
    @Override
    public List<Sku> exportSku(Sku sku)
    {
        return skuMapper.selectSkuList(sku);
    }

    /**
     * 校验商品编码是否唯一
     *
     * @param sku 商品信息
     * @return 结果
     */
    @Override
    public boolean checkSkuCodeUnique(Sku sku)
    {
        Long skuId = sku.getId() == null ? -1L : sku.getId();
        Sku info = skuMapper.selectSkuById(skuId);
        if (info != null && info.getId().longValue() != skuId.longValue())
        {
            return false;
        }
        return true;
    }
}